﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using GestionePolveriLib.BL;
using GestionePolveriLib.Facades;
using GestionePolveriLib.Facades.Extensions;
using System.Diagnostics;
using System.Windows.Forms;
using System.Transactions;
using GestionePolveri2.DAL;
using OfficeOpenXml; 



namespace GestionePolveriImporter
{
    public class MovimentoLottoBag
    {
        public Movimento Movimento { get; set; }
        public Lotto Lotto { get; set; }

        public MovimentoLottoBag()
        {
        }

        public MovimentoLottoBag(Movimento movimento, Lotto lotto)
        {
            Movimento = movimento;
            Lotto = lotto;
        }
    }

    public static class ImportHelper
    {
        static Dictionary<string, FamigliaColore> m_lookupTable = null;
        static Dictionary<string, Fornitore> m_lookupFornitore = null;

        public static ExcelPackage ExcelPackage { get; set; }

        public static List<Polvere> ImportPolveri(int index, Importer importer)
        {
            List<Polvere> retValue = new List<Polvere>();

            FornitoriFacade ff = new FornitoriFacade();
            List<Fornitore> m_fornitoriLookup = ff.GetFornitori();

            int startRow = int.Parse(importer.Settings[index].StartRow);
            int endRow = int.Parse(importer.Settings[index].EndRow);

            ExcelWorksheet worksheet = ExcelPackage.Workbook.Worksheets[importer.Settings[index].WorkSheetName];

            PolveriComparer polveriComparer = new PolveriComparer();

            PolvereFacade pf = new PolvereFacade();
            for (int iRow = startRow; iRow <= endRow; iRow++)
            {
                int descrizione = importer.Map("Descrizione");
                int note = importer.Map("Note");
                int codicepolvere = importer.Map("codicepolvere");
                int fornitore = importer.Map("fornitore");

                Fornitore m_fornitore = m_fornitoriLookup.Find(x => x.Note.StartsWith(worksheet.Cell(iRow, fornitore).Value.Trim(), StringComparison.InvariantCultureIgnoreCase));
                
                Polvere p = pf.CreatePolvere(worksheet.Cell(iRow, codicepolvere).Value,
                                             worksheet.Cell(iRow, descrizione).Value,
                                             worksheet.Cell(iRow, note).Value, m_fornitore);

                if(!retValue.Contains(p, polveriComparer))
                 retValue.Add(p);
            }

            return retValue;
        }

        public static List<Colore> ImportColori(int index, Importer importer)
        {
            List<Colore> retValue = new List<Colore>();

            FamigliaColoriFacade fcf = new FamigliaColoriFacade();
            List<FamigliaColore> m_lookup = fcf.GetAll();

            int startRow = int.Parse(importer.Settings[index].StartRow);
            int endRow = int.Parse(importer.Settings[index].EndRow);

            ExcelWorksheet worksheet = ExcelPackage.Workbook.Worksheets[importer.Settings[index].WorkSheetName];

            ColoriComparer coloriComparer = new ColoriComparer();

            ColoriFacade pf = new ColoriFacade();
            for (int iRow = startRow; iRow <= endRow; iRow++)
            {
                int descrizione = importer.Map("Descrizione");
                int note = importer.Map("Note");
                int codiceColore = importer.Map("CodiceColore");
                int famiglia = importer.Map("Famiglia");

                FamigliaColore m_famiglia = m_lookup.Find(x => x.Descrizione.Contains(worksheet.Cell(iRow, famiglia).Value.Trim()));

                Colore p = pf.CreateColore(worksheet.Cell(iRow, codiceColore).Value,
                                             worksheet.Cell(iRow, descrizione).Value,
                                             worksheet.Cell(iRow, note).Value, m_famiglia);

                if(!retValue.Contains(p, coloriComparer))
                  retValue.Add(p);
            }

            return retValue;
        }

        public static List<ComposizioneColoreExt> ImportComposizioneColori(int index, Importer importer)
        {
            List<ComposizioneColoreExt> retValue = new List<ComposizioneColoreExt>();

            ColoriFacade cf = new ColoriFacade();
            List<Colore> m_colori = new List<Colore>();
            m_colori = cf.GetAll();

            PolvereFacade pf = new PolvereFacade();
            List<Polvere> m_polveri = pf.GetAll();

            int startRow = int.Parse(importer.Settings[index].StartRow);
            int endRow = int.Parse(importer.Settings[index].EndRow);

            ExcelWorksheet worksheet = ExcelPackage.Workbook.Worksheets[importer.Settings[index].WorkSheetName];

            ComposizioneColoreFacadeExt ccf = new ComposizioneColoreFacadeExt();
            for (int iRow = startRow; iRow <= endRow; iRow++)
            {
                int codiceColore = importer.Map("CodiceColore");
                int abase = importer.Map("Base");
                int codicePolvereBase = importer.Map("PolvereBase");
                int aVenatura = importer.Map("Venatura");
                int codicePolvereVenatura = importer.Map("PolvereVenatura");

                Colore m_colore = m_colori.Find(x => x.CodiceColore.Contains(worksheet.Cell(iRow, codiceColore).Value.Trim()));

                List<PolvereExt> m_polveri2 = new List<PolvereExt>(); 
                if (worksheet.Cell(iRow, abase).Value.ToLower().Equals("b", StringComparison.InvariantCultureIgnoreCase))
                {
                    Polvere polvere = m_polveri.Find(x => x.CodicePolvere.Contains(worksheet.Cell(iRow, codicePolvereBase).Value.Trim()));
                    PolvereExt p = new PolvereExt(polvere);
                    p.Base = true;
                    m_polveri2.Add(p);
                }

                if (worksheet.Cell(iRow, aVenatura).Value.ToLower().Equals("v", StringComparison.InvariantCultureIgnoreCase))
                {
                    Polvere polvere = m_polveri.Find(x => x.CodicePolvere.Contains(worksheet.Cell(iRow, codicePolvereVenatura).Value.Trim()));
                    PolvereExt p = new PolvereExt(polvere);
                    p.Venatura = true;
                    m_polveri2.Add(p);
                }
                
                ComposizioneColoreExt ccExt = ccf.CreateComposizioneColore(m_colore, m_polveri2);

                retValue.Add(ccExt);
            }

            return retValue;
        }

        public static List<Polvere> ImportPolveriParticolariVenatura(int index, Importer importer)
        {
            List<Polvere> retValue = new List<Polvere>();

            FornitoriFacade ff = new FornitoriFacade();
            List<Fornitore> m_fornitoriLookup = ff.GetFornitori();

            int startRow = int.Parse(importer.Settings[index].StartRow);
            int endRow = int.Parse(importer.Settings[index].EndRow);

            ExcelWorksheet worksheet = ExcelPackage.Workbook.Worksheets[importer.Settings[index].WorkSheetName];

            PolveriComparer polveriComparer = new PolveriComparer();

            PolvereFacade pf = new PolvereFacade();
            for (int iRow = startRow; iRow <= endRow; iRow++)
            {
                int descrizione = importer.Map("Descrizione");
                int note = importer.Map("Note");
                int codicepolvere = importer.Map("codicepolvere");
                int fornitore = importer.Map("fornitore");

                Fornitore m_fornitore = m_fornitoriLookup.Find(x => x.Note.StartsWith(worksheet.Cell(iRow, fornitore).Value.Trim(), StringComparison.InvariantCultureIgnoreCase));

                Polvere p = pf.CreatePolvere(worksheet.Cell(iRow, codicepolvere).Value,
                                             worksheet.Cell(iRow, descrizione).Value,
                                             worksheet.Cell(iRow, note).Value, m_fornitore);

                if (!retValue.Contains(p, polveriComparer))
                  retValue.Add(p);
            }

            return retValue;
        }

        public static List<Lotto> ImportLotti(int index, Importer importer)
        {
            List<Lotto> retValue = new List<Lotto>();

            try
            {
                PolvereFacade pf = new PolvereFacade();
                FamigliaColoriFacade fcf = new FamigliaColoriFacade();
                List<FamigliaColore> m_lookup = fcf.GetAll();
                List<Polvere> m_polveri = pf.GetAll();

                Dictionary<string, Polvere> m_polvereLookup = new Dictionary<string, Polvere>();
                foreach (Polvere p in m_polveri)
                {
                    m_polvereLookup.Add(p.CodicePolvere, p);
                }

                int startRow = int.Parse(importer.Settings[index].StartRow);
                int endRow = int.Parse(importer.Settings[index].EndRow);

                ExcelWorksheet worksheet = ExcelPackage.Workbook.Worksheets[importer.Settings[index].WorkSheetName];

                ColoriComparer coloriComparer = new ColoriComparer();

                MovimentiFacade mf = new MovimentiFacade();
                LottoFacade lf = new LottoFacade();

                int data = importer.Map("Data");
                int tipo = importer.Map("TipoMovimento");
                int impianto = importer.Map("Destinazione");
                int codicePolvere = importer.Map("CodicePolvere");

                int lotto = importer.Map("Lotto");
                int tipoScatola = importer.Map("TipoScatola");
                int flagRecupero = importer.Map("FlagRecupero");
                int numScatoleCarico = importer.Map("NumScatoleCarico");
                int quantitaCarico = importer.Map("QuantitaCarico");
                int numScatoleScarico = importer.Map("NumScatoleSCarico");
                int quantitaScarico = importer.Map("QuantitaSCarico");

                LottoComparer lottoComparer = new LottoComparer();

                for (int iRow = startRow; iRow <= endRow; iRow++)
                {
                    Polvere polvere = m_polvereLookup[worksheet.Cell(iRow, codicePolvere).Value];

                    if (polvere == null)
                    {
                        Console.WriteLine(worksheet.Cell(iRow, codicePolvere).Value);
                    }

                    Lotto m_lotto = lf.CreateLotto(worksheet.Cell(iRow, lotto).Value, "N.D.", DateTime.Now, 0, 0, polvere.ID);

                    if (!retValue.Contains(m_lotto, lottoComparer))
                        retValue.Add(m_lotto);
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            return retValue;
        }

        /*
        public static List<MovimentoLottoBag> ImportMovimenti___(int index, Importer importer)
        {
            List<MovimentoLottoBag> retValue = new List<MovimentoLottoBag>();

            string codicePolvere = string.Empty;
            string scatolaPezzatura = string.Empty;
            string destinazione = string.Empty;
            GestionePolveri2.DAL.Sheet1 temp = null;
            List<GestionePolveri2.DAL.Sheet1> m_nonImportati = new List<GestionePolveri2.DAL.Sheet1>();

            try
            {
                LottoFacade lf = new LottoFacade();
                PolvereFacade pf = new PolvereFacade();
                FamigliaColoriFacade fcf = new FamigliaColoriFacade();
                List<FamigliaColore> m_lookup = fcf.GetAll();
                List<Polvere> m_polveri = pf.GetAll();

                Dictionary<string, Polvere> m_polvereLookup = new Dictionary<string, Polvere>();
                foreach (Polvere p in m_polveri)
                {
                    m_polvereLookup.Add(p.CodicePolvere.ToLower(), p);
                }

                ScatoleFacade sf = new ScatoleFacade();
                List<Scatola> scatole = sf.GetScatole();
                Dictionary<double, Scatola> m_scatoleLookup = new Dictionary<double, Scatola>();
                foreach (Scatola p in scatole)
                {
                    m_scatoleLookup.Add(p.Pezzatura, p);
                }

                ImpiantoFacade impf = new ImpiantoFacade();
                List<Impianto> impianti = impf.GetImpianti();
                Dictionary<string, Impianto> m_impiantiLookup = new Dictionary<string, Impianto>();
                foreach (Impianto p in impianti)
                {
                    m_impiantiLookup.Add(p.Nome.ToLower(), p);
                }


                int startRow = int.Parse(importer.Settings[index].StartRow);
                int endRow = int.Parse(importer.Settings[index].EndRow);

                ExcelWorksheet worksheet = ExcelPackage.Workbook.Worksheets[importer.Settings[index].WorkSheetName];

                ColoriComparer coloriComparer = new ColoriComparer();

                MovimentiFacade mf = new MovimentiFacade();

                GestionePolveriEntities ctx = new GestionePolveriEntities();
                var objs = from x in ctx.Sheet1 select x;

                foreach (Sheet1 pi2 in objs)
                {
                    temp = pi2;

                    codicePolvere = pi2.codicepolvere;
                    scatolaPezzatura = pi2.scatola.Value.ToString();
                    destinazione = pi2.destinazione;

                    Polvere polvere = null;
                    Scatola scatola = null;
                    Impianto imp = null;

                    try
                    {
                        pf.LookUpPolvere(pi2.codicepolvere.ToLower());
                        polvere = m_polvereLookup[pi2.codicepolvere.ToLower()];
                        scatola = m_scatoleLookup[double.Parse(pi2.scatola.Value.ToString())];
                        imp = m_impiantiLookup[pi2.destinazione.ToLower()];
                    }
                    catch (Exception ex)
                    {
                        m_nonImportati.Add(pi2);

                        continue;
                    }

                    ///
                    CausaliMagazzinoFacade cmf = new CausaliMagazzinoFacade();
                    CausaleMagazzino cm = null;
                    CausaleScarico cs = null;
                    double numScat = 0;
                    double q = 0;
                    string tipomov = string.Empty;
                    string numDDT = "N.D.";

                    if (pi2.quantitàCarico.Value.ToString() != string.Empty)
                    {
                        tipomov = "C";

                        if (pi2.tipo.ToLower().Equals("inventario"))
                        {
                            numDDT = "INVENTARIO";
                        }

                        cm = cmf.GetCausaleByCod("C");

                        numScat = pi2.scatoleCarico.Value;

                        q = pi2.quantitàCarico.Value;
                    }
                    else
                    {
                        if (pi2.quantitàScarico != string.Empty)
                        {
                            tipomov = "S";

                            if (pi2.tipo.ToLower().Equals("correzione"))
                            {
                                imp = m_impiantiLookup["allineamento inventario"];
                            }

                            cm = cmf.GetCausaleByCod("S");

                            numScat = double.Parse(pi2.scatoleScarico);

                            q = double.Parse(pi2.quantitàScarico);

                            CausaliScaricoFacade csf = new CausaliScaricoFacade();
                            string flagR = pi2.flag;
                            if (flagR.Trim().Equals("recupero", StringComparison.InvariantCultureIgnoreCase))
                            {
                                cs = csf.GetCausaleScarico("R");
                            }
                            else
                            {
                                if (flagR.Trim().Equals("perdere", StringComparison.InvariantCultureIgnoreCase))
                                {
                                    cs = csf.GetCausaleScarico("S");
                                }
                            }
                        }
                    }

                    DateTime dt = pi2.data.Value;

                    MovimentoLottoBag mlb = new MovimentoLottoBag();

                    Lotto m_lotto = lf.CreateLotto(pi2.lotto, numDDT, DateTime.Now, 0, 0, polvere.ID);

                    mlb.Lotto = m_lotto;
                    mlb.Movimento = mf.CreateMovimento(tipomov, 0,
                                       polvere.ID,
                                       dt,
                                       (cs == null ? 0 : cs.ID),
                                       cm.ID,
                                       scatola.ID,
                                       imp.ID,
                                       "",
                                       numScat,
                                       q,
                                       false,
                                       false,
                                       m_lotto);

                    if (!retValue.Contains(mlb))
                        retValue.Add(mlb);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(temp.codicepolvere);

                Console.WriteLine(ex.Message);
            }

            foreach (Sheet1 ppp in m_nonImportati)
            {
                Console.WriteLine("{0}, {1}, {2}, {3}, {4}", ppp.id, ppp.data, ppp.codicepolvere, ppp.destinazione, ppp.lotto);
            }


            return retValue;
        }
        */

        public static List<MovimentoLottoBag> ImportMovimenti(int index, Importer importer)
        {
            List<MovimentoLottoBag> retValue = new List<MovimentoLottoBag>();
            int index1 = 1;
            long polvereID = -1;

            try
            {
                // caricamento delle collections di lookup...

                // tipo --> Inventario Magazzino...
                // destinazione --> impianto...
                // flag --> Causali Scarico...
                Stopwatch sw = Stopwatch.StartNew();

                //string cn = @"metadata=res://*/GestionePolveri.csdl|res://*/GestionePolveri.ssdl|res://*/GestionePolveri.msl;provider=System.Data.SqlClient;provider connection string=&quot;data source=MELNAC-PC\SQLEXPRESS;initial catalog=GestionePolveri;integrated security=True;multipleactiveresultsets=True;App=EntityFramework&quot;";
                //string cn1 = @"Data Source=MELNAC-PC\SQLEXPRESS;Integrated Security=SSPI;Initial Catalog=GestionePolveri;";
                string cn2 = "name=GestionePolveriEntitiesDAL";
                Polvere polvere = null;
                Colore colore = null;

                PolvereFacade pf = new PolvereFacade();
                ColoriFacade cf = new ColoriFacade();
                LottoFacade lf = new LottoFacade();
                MovimentiFacade mf = new MovimentiFacade();
                ComposizioneColoreFacadeExt ccfExt = new ComposizioneColoreFacadeExt();

                GestionePolveriEntities ctx = new GestionePolveriEntities();
                var spannedData = from x in ctx.Sheet1 orderby x.tipo ascending select x;

                TransactionOptions op = new TransactionOptions();
                op.IsolationLevel = IsolationLevel.ReadUncommitted;
                using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, op))
                {
                    foreach (Sheet1 sd in spannedData)
                    {
                        if ((!string.IsNullOrWhiteSpace(sd.Fornitore)) && (sd.Fornitore.Trim() == "?")) continue;

                        // check se polvere XXXX
                        if (sd.codicepolvere.Trim().Equals("xxxx", StringComparison.InvariantCultureIgnoreCase))
                        {
                            polvereID = sd.id;

                            // devo creare la polvere XXXX, cercare/creare il colore, creare l'associazione
                            // 1) creazione polvere...
                            string codicePolvere = string.Format("xxxx - {0}", sd.CodicePolvereReale.Trim());
                            Fornitore fornitore = GetFornitore(sd.Fornitore.Trim());

                            string note = (string.IsNullOrWhiteSpace(sd.NotePolvere) ? string.Empty : sd.NotePolvere);
                            polvere = pf.CreatePolvere(codicePolvere, codicePolvere, note, fornitore);
                            polvere.IsCodiceCustom = true;

                            pf.Add(polvere);

                            //// 2) cercare/creare colore...
                            FamigliaColore famiglia = GetFamiglia(sd.destinazione);

                            colore = cf.Get(sd.Colore);
                            if (colore == null)
                            {
                                colore = cf.CreateColore(sd.Colore, "colore creato da import", "colore creato da import", famiglia);
                                cf.Add(colore);
                            }

                            //// 3) crea la formula...
                            List<PolvereExt> polveri = new List<PolvereExt>();
                            polveri.Add(new PolvereExt(polvere) { Base = true, Applicazione="b" });

                            ComposizioneColoreExt ccExt = new ComposizioneColoreExt();
                            ccExt.Applicazione = "b";
                            ccExt.Colore = colore;
                            ccExt.Polveri = polveri;
                            ccfExt.Add(ccExt);
                        }
                        else
                        {
                            // 1) crea polvere...
                            polvere = GetPolvere(sd.codicepolvere);
                            if (polvere == null)
                            {
                                Fornitore fornitore = GetFornitore(sd.Fornitore.Trim());

                                string note = (string.IsNullOrWhiteSpace(sd.NotePolvere) ? string.Empty : sd.NotePolvere);
                                polvere = pf.CreatePolvere(sd.codicepolvere, sd.codicepolvere, note, fornitore);

                                pf.Add(polvere);
                            }
                        }

                        index1++;

                        // 4) creo il lotto...
                        string numDDT = CreateNumDDT(sd);
                        Lotto lotto = lf.CreateLotto(sd.lotto, numDDT, DateTime.Now, 0, 0, polvere.ID);
                        
                        //// 5) creo il movimento...
                        Movimento movimento = CreateMovimento(sd, polvere, lotto);
                        
                        //
                        MovimentoLottoBag mlb = new MovimentoLottoBag();
                        mlb.Lotto = lotto;
                        mlb.Movimento = movimento;

                        if (!retValue.Contains(mlb))
                            retValue.Add(mlb);


                    }

                    scope.Complete();
                }

                sw.Stop();
                // Report the results
                MessageBox.Show(string.Format("Time used (float): {0} ms\nTime used (rounded): {1} ms", sw.Elapsed.Seconds,
                                                                                                          sw.ElapsedMilliseconds));
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            return retValue;
        }

        private static Movimento CreateMovimento(GestionePolveri2.DAL.Sheet1 sheet, Polvere polvere, Lotto lotto)
        {
            Movimento retValue = null;

            CausaliMagazzinoFacade cmf = new CausaliMagazzinoFacade();
            CausaleMagazzino cm = null;
            CausaleScarico cs = null;
            double numScat = 0;
            double q = 0;
            string tipomov = string.Empty;
            Impianto imp = null;
            Scatola scatola = null;

            imp = GetImpianto(sheet.destinazione);

            if (sheet.quantitàCarico != null)
            {
                tipomov = "C";

                cm = cmf.GetCausaleByCod("C");

                numScat = sheet.scatoleCarico.GetValueOrDefault();

                q = sheet.quantitàCarico.GetValueOrDefault();
            }
            else
            {
                double quantitaScarico = sheet.quantitàScarico.GetValueOrDefault();
                double scatoleScarico = sheet.scatoleScarico.GetValueOrDefault();

                if (quantitaScarico != 0)
                {
                    tipomov = "S";

                    if (sheet.tipo.ToLower().Equals("correzione"))
                    {
                        imp = GetImpianto("allineamento inventario");
                    }

                    cm = cmf.GetCausaleByCod("S");

                    numScat = scatoleScarico;

                    q = quantitaScarico;

                    CausaliScaricoFacade csf = new CausaliScaricoFacade();
                    string flagR = (sheet.flag == null ? string.Empty : sheet.flag);
                    if (flagR.Trim().Equals("recupero", StringComparison.InvariantCultureIgnoreCase))
                    {
                        cs = csf.GetCausaleScarico("R");
                    }
                    else
                    {
                        if (flagR.Trim().Equals("perdere", StringComparison.InvariantCultureIgnoreCase))
                        {
                            cs = csf.GetCausaleScarico("S");
                        }
                    }
                }
            }

            DateTime dt = sheet.data.Value;

            double m_scatola = 25;
            if (sheet.scatola.GetValueOrDefault() != 0)
            {
                m_scatola = sheet.scatola.GetValueOrDefault();
            }
            scatola = GetScatola(int.Parse(m_scatola.ToString()));

            MovimentiFacade mf = new MovimentiFacade();
            retValue = mf.CreateMovimento(tipomov, 0,
                   polvere.ID,
                   dt,
                   (cs == null ? 0 : cs.ID),
                   cm.ID,
                   scatola.ID,
                   imp.ID,
                   "",
                   numScat,
                   q,
                   false,
                   false,
                   lotto);

            return retValue;
        }

        private static string CreateNumDDT(GestionePolveri2.DAL.Sheet1 sheet)
        {
            string retValue = "N.D";

            if (sheet.quantitàScarico != null)
            {
                if (sheet.quantitàScarico.ToString() != string.Empty)
                {
                    if (sheet.tipo != null)
                    {
                        if (sheet.tipo.ToLower().Equals("inventario"))
                        {
                            retValue = "INVENTARIO";
                        }
                    }
                }
            }

            return retValue;
        }

        public static Impianto GetImpianto(string nomeImpianto)
        {
            Impianto retValue = null;

            GestionePolveri2.DAL.GestionePolveriEntities ctx = new GestionePolveri2.DAL.GestionePolveriEntities();
            var obj = from x in ctx.Impianti
                           where x.Impianto.Equals(nomeImpianto, StringComparison.InvariantCultureIgnoreCase)
                           select new Impianto
                           {
                               ID = x.IDImpianto,
                               Nome = x.Impianto
                           };

            if (obj.Any())
            {
                retValue = obj.FirstOrDefault();
            }

            //ctx.Connection.Close();

            return retValue;
        }

        public static CausaleMagazzino GetCausaliMagazzino(string descrizione)
        {
            CausaleMagazzino retValue = null;

            GestionePolveri2.DAL.GestionePolveriEntities ctx = new GestionePolveri2.DAL.GestionePolveriEntities();
            var obj = from x in ctx.CausaliMagazzino
                           where x.Descrizione.Equals(descrizione, StringComparison.InvariantCultureIgnoreCase)
                           select new CausaleMagazzino
                           {
                               ID = x.IDCausale,
                               CodCausale = x.CodCausale
                           };

            if (obj.Any())
            {
                retValue = obj.FirstOrDefault();
            }

            //ctx.Connection.Close();

            return retValue;
        }

        public static CausaleScarico GetCausaliScarico(string descrizione)
        {
            CausaleScarico retValue = null;

            GestionePolveri2.DAL.GestionePolveriEntities ctx = new GestionePolveri2.DAL.GestionePolveriEntities();
            var obj = from x in ctx.CausaliScarico
                           where x.Descrizione.Equals(descrizione, StringComparison.InvariantCultureIgnoreCase)
                           select new CausaleScarico
                           {
                               ID = x.IDCausaleScarico,
                               CodCausale = x.CodCausaleScarico
                           };

            if (obj.Any())
            {
                retValue = obj.FirstOrDefault();
            }

            //ctx.Connection.Close();

            return retValue;
        }

        public static Fornitore GetFornitore(string descrizione)
        {
            Fornitore retValue = null;

            if (m_lookupFornitore == null)
            {
                GestionePolveri2.DAL.GestionePolveriEntities ctx = new GestionePolveri2.DAL.GestionePolveriEntities();
                var objs = from x in ctx.AnagFornitori
                           select new Fornitore
                           {
                               ID = x.IDFornitore,
                               Descrizione = x.Descrizione
                           };

                if (objs.Any())
                {
                    m_lookupFornitore = new Dictionary<string, Fornitore>();

                    foreach (Fornitore f in objs)
                    {
                        m_lookupFornitore.Add(f.Descrizione, f);
                    }
                }
            }

            KeyValuePair<string, Fornitore> elem = m_lookupFornitore.FirstOrDefault(x => x.Key.Contains(descrizione));
            retValue = elem.Value;

            //retValue = m_lookupFornitore[descrizione];

            ////GestionePolveriImporter.GestionePolveriEntities ctx = new GestionePolveriEntities();
            //var obj = from x in ctx.AnagFornitori
            //               where x.Descrizione.Contains(descrizione)
            //               select new Fornitore
            //               {
            //                   ID = x.IDFornitore,
            //                   Descrizione = x.Descrizione
            //               };

            //if (obj.Any())
            //{
            //    retValue = obj.FirstOrDefault();
            //}

            //ctx.Connection.Close();

            return retValue;
        }

        private static Scatola GetScatola(int pezzatura)
        {
            Scatola retValue = null;

            GestionePolveri2.DAL.GestionePolveriEntities ctx = new GestionePolveri2.DAL.GestionePolveriEntities();
            var obj = from x in ctx.FormatoScatole
                      where x.Pezzatura == pezzatura
                      select new Scatola
                      {
                          ID = x.IDFormato,
                          Pezzatura = x.Pezzatura
                      };

            if (obj.Any())
            {
                retValue = obj.FirstOrDefault();
            }

            //ctx.Connection.Close();

            return retValue;
        }

        public static Polvere GetPolvere(string codicePolvere)
        {
            Polvere retValue = null;

            GestionePolveri2.DAL.GestionePolveriEntities ctx = new GestionePolveri2.DAL.GestionePolveriEntities();
            var obj = from x in ctx.AnagPolveri
                      where x.CodicePolvere.Contains(codicePolvere)
                      select new Polvere
                      {
                          ID = x.IDPolvere,
                          CodicePolvere = x.CodicePolvere
                      };

            if (obj.Any())
            {
                retValue = obj.FirstOrDefault();
            }


            //ctx.Connection.Close();
            return retValue;
        }

        public static FamigliaColore GetFamiglia(string impianto)
        {
            FamigliaColore retValue = null;

            if (m_lookupTable == null)
            {
                GestionePolveri2.DAL.GestionePolveriEntities ctx = new GestionePolveri2.DAL.GestionePolveriEntities();
                var objs = from x in ctx.AnagFamiglie
                           select new FamigliaColore
                           {
                               ID = x.IDFamiglia,
                               Descrizione = x.Descrizione
                           };

                if (objs.Any())
                {
                    m_lookupTable = new Dictionary<string, FamigliaColore>();

                    foreach (FamigliaColore p in objs)
                    {
                        m_lookupTable.Add(p.Descrizione.ToLower(), p);
                    }
                }

                //ctx.Connection.Close();
            }

            if (impianto.Contains("colorwood"))
            {
                retValue = m_lookupTable["colorwood"];
            }
            else
            {
                retValue = m_lookupTable["ral"];
            }

            return retValue;
        }
    }
}
